home *** CD-ROM | disk | FTP | other *** search
/ Amiga Tools 5 / Amiga Tools 5.iso / grafik / converter / limbo4.0 / src / 3d / main.c < prev    next >
Encoding:
C/C++ Source or Header  |  1996-07-16  |  9.4 KB  |  267 lines
  1. #include "includes.h"
  2.  
  3.  int Quiet=FALSE;
  4.  
  5. /**************************************|****************************************
  6. Routine   : main
  7. Input  par: int argc (argument count)
  8.             char *argv[] (pointer to arguments)
  9. Output par: none
  10. Function  : Main program. Inputs arguments from user. Calls Encoder.
  11. ***************************************|***************************************/
  12.  
  13.  void main(int argc,char *argv[])
  14.   {
  15.    char c;
  16.    char *dd,*filename,*cmd;
  17.    int B=2,Delta=4; /* default vals */ 
  18.    int Iterations=6,MaxX=0,MaxY=0,MaxZ=0,NSquare=0,LLevels=0,OffX=0,OffY=0,OffZ=0,snr;
  19.    int MinList=4,MaxList=10,FeatureDimensions=3,GridResolution=1000,i;
  20.    
  21.    LimboHeader *Head=GimmeALimboHeader();
  22.    Parameter   *Par;
  23.    Transformation ****FCCodes;
  24.    
  25.    Par=GimmeAParameter(); /* Initialize vars */
  26.    Par->TMainSub=100;  /* Threshold for main/sub break up */
  27.    Par->TShadeEdge=50; /* Threshold for shade/edge classification */
  28.    Par->TPostProcess=-1; /* Threshold for postprocession */
  29.    Par->XBits=7;  /* X coord bits */
  30.    Par->YBits=7;  /* Y coord bits */
  31.    Par->ZBits=7;  /* Z coord bits */
  32.    Par->SBits=1;  /* mainsub bits - do not change */
  33.    Par->ABits=4;  /* alpha bits */
  34.    Par->AMax=1.0; /* alpha max */
  35.    Par->AMin=0.4; /* alpha min */
  36.    Par->DBits=6;  /* Delta G bits */
  37.    Par->GBits=8;  /* Gray bits - do not change */
  38.    Par->TBits=3;  /* Transformation bits - do not change */
  39.    
  40.    if (argc<3) LearnUsage();
  41.    while(--argc>2)
  42.     {
  43.      c=(*++argv)[0];
  44.      if (!(c=='-')) ErrorHandler(UNKNOWN_OPTION,argv[0]);
  45.      else
  46.       {
  47.        c=(*argv)[1];
  48.        dd= &(*argv)[1];
  49.        switch(c)
  50.         {
  51.          case 'x': MaxX=ReadInteger(&((*argv)[2]));
  52.          break;
  53.          case 'y': MaxY=ReadInteger(&((*argv)[2]));
  54.          break;
  55.          case 'z': MaxZ=ReadInteger(&((*argv)[2]));
  56.          break;
  57.          case 'm': MinList=ReadInteger(&((*argv)[2]));
  58.          break;
  59.          case 's': MaxList=ReadInteger(&((*argv)[2]));
  60.          break;
  61.          case 'b': /* Range blocksize */
  62.           {
  63.            B=ReadInteger(&((*argv)[2]));
  64.            if (B<2) B=2;
  65.           }
  66.          break;
  67.          case 'i': Iterations=ReadInteger(&(*argv)[2]); /* Decoder iterations */
  68.          break;
  69.          case 'l': LLevels=ReadInteger(&(*argv)[2]); /* expand levels */
  70.          break;
  71.          case 'n': NSquare=ReadInteger(&(*argv)[2]); /* n-level square */
  72.          break;
  73.          case 'd': Delta=ReadInteger(&((*argv)[2])); /* delta step */
  74.          break;
  75.          case 'f': FeatureDimensions=ReadInteger(&((*argv)[2]));
  76.          break;
  77.          case 'r': GridResolution=ReadInteger(&((*argv)[2]));
  78.          break;
  79.          case 'q': Quiet=TRUE;
  80.          break;
  81.          case 'A': /* alpha range */ 
  82.           {
  83.            if      (!strncmp("Amin",dd,4)) Par->AMin=ReadFloat(&((*argv)[5]));
  84.            else if (!strncmp("Amax",dd,4)) Par->AMax=ReadFloat(&((*argv)[5]));
  85.            else ErrorHandler(UNKNOWN_OPTION,argv[0]);
  86.            if (Par->AMax>2.55) Par->AMax=2.55;
  87.            if (Par->AMin<0.00) Par->AMin=0.00;
  88.            break;
  89.           }
  90.          case 'Q': /* quant */ 
  91.           {
  92.            if      (!strncmp("Qa",dd,2)) Par->ABits=ReadInteger(&((*argv)[3]));
  93.            else if (!strncmp("Qd",dd,2)) Par->DBits=ReadInteger(&((*argv)[3]));
  94.            else ErrorHandler(UNKNOWN_OPTION,argv[0]);
  95.            break;
  96.           }
  97.          case 'o': /* offsets */ 
  98.           {
  99.            if      (!strncmp("ox",dd,2)) OffX=ReadInteger(&((*argv)[3]));  /* offset x  */
  100.            else if (!strncmp("oy",dd,2)) OffY=ReadInteger(&((*argv)[3]));  /* offset y  */
  101.            else ErrorHandler(UNKNOWN_OPTION,argv[0]);
  102.            break;
  103.           }
  104.          case 'T':  /* Threshold parameters */
  105.           {
  106.            /* main/sub thres */
  107.            if      (!strncmp("Tm",dd,2)) Par->TMainSub =ReadInteger(&((*argv)[3]));
  108.            /* shade/edge thres */
  109.            else if (!strncmp("Te",dd,2)) Par->TShadeEdge=ReadInteger(&((*argv)[3]));
  110.            /* post processing */
  111.            else if (!strncmp("Tp",dd,2)) Par->TPostProcess=ReadInteger(&((*argv)[3]));
  112.            else ErrorHandler(UNKNOWN_OPTION,argv[0]);
  113.            break;
  114.           }
  115.          default: ErrorHandler(UNKNOWN_OPTION,argv[0]);
  116.          break;
  117.         }
  118.       }
  119.     }
  120.    
  121.    cmd = &(*++argv)[0];
  122.    filename = &(*++argv)[0];
  123.    
  124.    c=cmd[0];
  125.    switch(c)
  126.     {
  127.      case 'e': /* encode mode */
  128.       {
  129.        int
  130.        StartBlockSize,DeltaSize,Res=pow((float)GridResolution,1.0/(float)FeatureDimensions)+0.5;
  131.        PoolStructure *Pool;
  132.        BitMap3D *DstImg,*Image;
  133.        clock_t cpu,cpustart;
  134.        
  135.        vprintf(stderr,"Encoding...\n   File:'%s'",filename);
  136.        
  137.        StartBlockSize=B<<NSquare;
  138.        DeltaSize=Delta;
  139.        
  140.        vprintf(stderr,"\nParameters...");
  141.        for (i=NSquare;i>=0;i--) 
  142.        vprintf(stderr,"\n   Level %d:  Domain block size %3d  Range block size %3d  Delta %3d",
  143.                i,B<<(1+i),B<<i,Delta);
  144.        vprintf(stderr,"\n   Threshold for shades/edges:%4d",Par->TShadeEdge);
  145.        vprintf(stderr,"\n   Threshold for main/subs:   %4d",Par->TMainSub);
  146.        vprintf(stderr,"\n   Threshold for postprocess: %4d",Par->TPostProcess);
  147.        vprintf(stderr,"\n   Minimum search list size:  %4d",MinList);
  148.        vprintf(stderr,"\n   Maximum search list size:  %4d",MaxList);
  149.        vprintf(stderr,"\n   Feature space dimensions:  %4d",FeatureDimensions);
  150.        vprintf(stderr,"\n   Feature grid resolution: %6d (%d)",GridResolution,Res);
  151.        
  152.        Image=LoadBitMap3D(filename,MaxX,MaxY,MaxZ,OffX,OffY,2*StartBlockSize,ORGGFX);
  153.        
  154.        Par->XBits=(int)ceil(log((double)(Image->XSize)/Delta)/log(2.0));
  155.        Par->YBits=(int)ceil(log((double)(Image->YSize)/Delta)/log(2.0));
  156.        Par->ZBits=(int)ceil(log((double)(Image->ZSize)/Delta)/log(2.0));
  157.        vprintf(stderr,"\n   X Bit:%d   Y Bit:%d   Z Bit:%d",Par->XBits,Par->YBits,Par->ZBits);
  158.        
  159.        cpustart=clock();
  160.        
  161.        vprintf(stderr,"\nGenerating Domain and Range Pool...");
  162.        
  163.        Pool=FindPool3D(Image,FeatureDimensions,Res,Par->TShadeEdge,NSquare,
  164.                        StartBlockSize,DeltaSize);
  165.        
  166.        cpu=(clock()-cpustart)/CLOCKS_PER_SEC;
  167.        vprintf(stderr,"\n   Pool Generation CPU time used:%d [sec]",cpu);
  168.        
  169.        FCCodes=Encode3D(Image,NSquare,StartBlockSize,Pool,Par,MinList,MaxList);
  170.        
  171.        cpu=(clock()-cpustart)/CLOCKS_PER_SEC;
  172.        vprintf(stderr,"\nCPU time used:%d [sec]",cpu);
  173.        
  174.        DstImg=Decode3D(FCCodes,Image->ImgType,Image->XSize,Image->YSize,Image->ZSize,
  175.                        StartBlockSize,Iterations,0);
  176.        
  177.        snr=100*PSNR3D(Image,DstImg);
  178.        
  179.        Head->HeadSize=(unsigned char)sizeof(LimboHeader)+LIMBOSTRINGSIZE;
  180.        Head->Type=(unsigned char)Image->ImgType;
  181.        Head->MSBx=(unsigned char)(Pool->RangeX*StartBlockSize/256);
  182.        Head->LSBx=(unsigned char)(Pool->RangeX*StartBlockSize-Head->MSBx*256);
  183.        Head->MSBy=(unsigned char)(Pool->RangeY*StartBlockSize/256);
  184.        Head->LSBy=(unsigned char)(Pool->RangeY*StartBlockSize-Head->MSBy*256);
  185.        Head->MSBz=(unsigned char)(Pool->RangeZ*StartBlockSize/256);
  186.        Head->LSBz=(unsigned char)(Pool->RangeZ*StartBlockSize-Head->MSBy*256);
  187.        Head->MSBox=(unsigned char)(OffX/256);
  188.        Head->LSBox=(unsigned char)(OffX-Head->MSBox*256);
  189.        Head->MSBoy=(unsigned char)(OffY/256);
  190.        Head->LSBoy=(unsigned char)(OffY-Head->MSBoy*256);
  191.        Head->MSBoz=(unsigned char)(OffZ/256);
  192.        Head->LSBoz=(unsigned char)(OffZ-Head->MSBoy*256);
  193.        
  194.        Head->Col=(unsigned char)8;
  195.        Head->B=(unsigned char)B;
  196.        Head->Delta=(unsigned char)Delta;
  197.        Head->NSquare=(unsigned char)NSquare;
  198.        
  199.        Head->XBits=Par->XBits;
  200.        Head->YBits=Par->YBits;
  201.        Head->ZBits=Par->ZBits;
  202.        
  203.        if (NSquare) Head->SBits=Par->SBits;
  204.        else Head->SBits=0;
  205.        Head->ABits=Par->ABits;
  206.        Head->AMax=(unsigned char)(Par->AMax*100.0); /* max = 2.55 */
  207.        Head->AMin=(unsigned char)(Par->AMin*100.0);
  208.        Head->DBits=Par->DBits;
  209.        Head->GBits=Par->GBits;
  210.        Head->TBits=Par->TBits;
  211.        
  212.        Head->MSBSNR=(unsigned char)(snr/256);
  213.        Head->LSBSNR=(unsigned char)(snr-Head->MSBSNR*256);
  214.        Head->MSBCPU=(unsigned char)(cpu/256);
  215.        Head->LSBCPU=(unsigned char)(cpu-Head->MSBCPU*256);
  216.        
  217.        SaveFC3D(FCCodes,filename,Head);
  218.        SaveAndView3D(filename,DstImg);
  219.        vprintf(stderr,"\nDone!\n");
  220.       }
  221.      break;
  222.      
  223.      case 'd':  /* decode mode */
  224.       {
  225.        BitMap3D *DstImg;
  226.        Head=LoadFC3D(&FCCodes,filename);
  227.        DstImg=Decode3D(FCCodes,Head->Type,Head->MSBx*256+Head->LSBx,Head->MSBy*256+Head->LSBy,
  228.                        Head->MSBz*256+Head->LSBz,Head->B<<Head->NSquare,Iterations,LLevels);
  229.        SaveAndView3D(filename,DstImg);
  230.        vprintf(stderr,"\nDone!\n");
  231.       }
  232.      break;
  233.      
  234.      case 'v':  /* view fractal header */
  235.       {
  236.        Quiet=FALSE;
  237.        Head=LoadFC3D(&FCCodes,filename);
  238.        HeadInfo3D(FCCodes,Head);
  239.        vprintf(stderr,"\nDone!\n");
  240.       }
  241.      break;
  242.      
  243.      case 'a':  /* analyze fractal code - produce error image, edg, sha images */
  244.       {
  245.        /* 
  246.        Quiet=FALSE;
  247.        BitMapAnalyze3D(filename,Iterations);
  248.        vprintf(stderr,"\nDone!\n");
  249.        */
  250.       }
  251.      break;
  252.      
  253.      case 't':  /* test mode */
  254.       {
  255.        Quiet=FALSE;
  256.        Test(filename);
  257.        vprintf(stderr,"\nDone!\n");
  258.       }
  259.      break;
  260.      
  261.      default : ErrorHandler(UNKNOWN_OPTION,cmd);
  262.      break;
  263.     }
  264.   }
  265.  
  266.  
  267.